
// /**
//  * @param {number[][]} rectangles
//  * @return {number}
//  */
// var rectangleArea = function(rectangles) {
//     // 定义矩形宽&高
//     const width_Height = [];
//     for(const [x1, y1, x2, y2] of rectangles){
//         const height = [y1, y2];
//         // 宽从左至右，需区分
//         width_Height.push({left: true, width: x1, height});
//         width_Height.push({left: false, width:x2, height});
//     }
//     width_Height.sort((a, b) => a.width - b.width);
//     const allHeights = [];
//     // 插入高
//     function insertHeight(height){
//         const [start, end] = height;
//         const index = allHeights.findIndex(item => start < item[0] || (start === item[0] && end > item[1]));
//         if(index === -1) {
//             allHeights.push(height);
//         } else {
//             allHeights.splice(index, 0, height);
//         }
//     }
//     // 删除高
//     function removeHeight(height){
//         const index = allHeights.indexOf(height);
//         if(index !== -1) allHeights.splice(index, 1)
//     }
//     // 计算矩形面积
//     function calcArea(width){
//         const mergeHeight = [];
//         for(const height of allHeights){
//             if(!mergeHeight.length){
//                 mergeHeight.push(height.slice());
//             } else {
//                 const tempH = mergeHeight[mergeHeight.length - 1];
//                 const end1 = tempH[1];
//                 // 高重叠，需合并
//                 const [start2, end2] = height;
//                 start2 < end1 ? tempH[1] = Math.max(end1, end2) : start2 === end1 ? tempH[1] = end2 : mergeHeight.push(height.slice());
//             }
//         }
//         const mWidth = BigInt(width - tempW);
//         return mergeHeight.map(([start, end]) => BigInt(end - start)).reduce((area, height) => area + mWidth * height, 0n);
//     }
//     let area = 0n;
//     let tempW = 0;
//     for(const {left, width, height} of width_Height) {
//         if(width !== tempW){
//             area += calcArea(width);
//             tempW = width;
//         }
//         if(left){
//             insertHeight(height);
//         }else{
//             removeHeight(height);
//         }
//     }
//     return area % 1000000007n
// };


// 0n: js中用于显示大数字的定义 普通的数字超过一定数值会丢失精度 这种方式是专门做大数字的运算用的
// arbitrary precision integers are not supported by current javascript version
// 当前javascript版本不支持任意精度整数


// const MOD = BigInt(1e9 + 7)
//
// function compress(iterator) {
//     const xToY = new Map(), yToX = []
//     let counter = 0
//
//     for (const i of iterator) {
//         if (!xToY.has(i)) {
//             xToY.set(i, counter)
//             yToX.push(i)
//             counter++
//         }
//     }
//
//     return [xToY, yToX]
// }
//
// /**
//  * @param {number[][]} rectangles
//  * @return {number}
//  */
// var rectangleArea = function(rectangles) {
//     const verticalLocs = [], horizontalLocs = []
//     for (const rect of rectangles) {
//         verticalLocs.push(rect[0])
//         horizontalLocs.push(rect[1])
//         verticalLocs.push(rect[2])
//         horizontalLocs.push(rect[3])
//     }
//
//     verticalLocs.sort((a, b) => a - b)
//     horizontalLocs.sort((a, b) => a - b)
//
//     const [verticalXToY, verticalYToX] = compress(verticalLocs)
//     const [horizontalXToY, horizontalYToX] = compress(horizontalLocs)
//
//     const m = []
//     for (let i = 0; i < horizontalYToX.length; i++) {
//         m.push(Array(verticalYToX.length).fill(0))
//     }
//
//     for (const rect of rectangles) {
//         const
//             x1 = verticalXToY.get(rect[0]), x2 = verticalXToY.get(rect[2]),
//             y1 = horizontalXToY.get(rect[1]), y2 = horizontalXToY.get(rect[3])
//
//         for (let y = y1; y < y2; y++) {
//             for (let x = x1; x < x2; x++) {
//                 m[y][x] = 1
//             }
//         }
//     }
//
//     // arbitrary precision integers are not supported by current javascript version
//     // let result = 0n
//
//     for (let y = 0; y < horizontalYToX.length - 1; y++) {
//         for (let x = 0; x < verticalYToX.length - 1; x++) {
//             if (m[y][x] <= 0) {
//                 continue
//             }
//
//             const width = BigInt(verticalYToX[x + 1] - verticalYToX[x])
//             const height = BigInt(horizontalYToX[y + 1] - horizontalYToX[y])
//
//             result = (result + width * height) % MOD
//         }
//     }
//
//     return Number(result)
// };


/*
* ts本身在这题上就是个大坑。

1.计算精度问题，这个js应该也有。这个可以依靠BigInt解决，然后就引发了第二个问题。
2.bigint与BigInt。在ts中还需要区分这两个。

* */